home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / util / auxencodings.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  9.8 KB  |  333 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import sys
  5. import warnings
  6. import xml
  7. import urllib2
  8. import codecs
  9. import locale
  10. import StringIO
  11. import zipfile
  12. import gzip
  13. from htmlentitydefs import name2codepoint, codepoint2name
  14. from collections import deque
  15. from codecs import CodecInfo
  16.  
  17. try:
  18.     import pylzma
  19.     HAVE_LZMA = True
  20. except ImportError:
  21.     HAVE_LZMA = False
  22.  
  23. ENCODE_LZMA = False
  24. __simplechars_enc = {
  25.     ord('<'): 'lt',
  26.     ord('>'): 'gt',
  27.     ord('"'): 'quot',
  28.     ord('&'): 'amp' }
  29. __simplechars_dec = dict((lambda .0: for k, v in .0:
  30. (v, unichr(k)))(__simplechars_enc.items()))
  31. __simplechars_dec['apos'] = unichr(ord("'"))
  32. _encodings = [
  33.     locale.getpreferredencoding(),
  34.     'ISO-8859-1',
  35.     sys.getfilesystemencoding(),
  36.     sys.getdefaultencoding()]
  37.  
  38. def register_codec(name, encode, decode):
  39.     
  40.     def _search(n):
  41.         if n == name:
  42.             return CodecInfo(name = name, encode = encode, decode = decode)
  43.         
  44.  
  45.     codecs.register(_search)
  46.  
  47.  
  48. def fuzzydecode(s, encoding = None, errors = 'strict'):
  49.     if isinstance(s, unicode):
  50.         warnings.warn('decoding unicode is not supported!')
  51.         return s
  52.     
  53.     encodings = list(_encodings)
  54.     if isinstance(encoding, basestring):
  55.         encodings.insert(0, encoding)
  56.     elif encoding is None:
  57.         pass
  58.     else:
  59.         encodings = list(encoding) + encodings
  60.     for e in encodings:
  61.         
  62.         try:
  63.             return s.decode(e, errors)
  64.         continue
  65.         except (UnicodeDecodeError, LookupError):
  66.             e = None
  67.             continue
  68.         
  69.  
  70.     
  71.     return s.decode(encoding, 'replace')
  72.  
  73.  
  74. def fuzzyencode(s, errors = 'strict'):
  75.     raise NotImplementedError
  76.  
  77.  
  78. def _xml_encode(input, errors = 'simple'):
  79.     simple = 'simple' in errors
  80.     origtype = type(input)
  81.     if simple:
  82.         chars = __simplechars_enc
  83.     else:
  84.         chars = codepoint2name
  85.     res = []
  86.     append = res.append
  87.     for ch in input:
  88.         och = ord(ch)
  89.         if och in chars:
  90.             append('&%s;' % chars[och])
  91.             continue
  92.         append(ch)
  93.     
  94.     return (origtype(''.join(res)), len(input))
  95.  
  96.  
  97. def _xml_decode(input, errors = 'strict'):
  98.     data = deque(input)
  99.     res = []
  100.     append = res.append
  101.     popleft = data.popleft
  102.     extendleft = data.extendleft
  103.     while data:
  104.         ch = popleft()
  105.         if ch == '&':
  106.             curtoken = ''
  107.             is_ref = False
  108.             is_num = False
  109.             is_hex = False
  110.             while len(curtoken) < 10 and data:
  111.                 nch = popleft()
  112.                 if nch == '#':
  113.                     is_num = True
  114.                 
  115.                 if is_num and len(curtoken) == 1 and nch == 'x':
  116.                     is_hex = True
  117.                 
  118.                 if nch == ';':
  119.                     is_ref = True
  120.                     break
  121.                 
  122.                 curtoken += nch
  123.             if not is_ref:
  124.                 extendleft(reversed(curtoken))
  125.                 append('&')
  126.                 continue
  127.             elif is_num:
  128.                 curtoken = curtoken[1:]
  129.                 if is_hex:
  130.                     curtoken = curtoken[1:]
  131.                     och = int(curtoken, 16)
  132.                 else:
  133.                     och = int(curtoken, 10)
  134.                 append(unichr(och))
  135.             elif curtoken in name2codepoint:
  136.                 append(unichr(name2codepoint[curtoken]))
  137.             elif curtoken in __simplechars_dec:
  138.                 append(__simplechars_dec[curtoken])
  139.             else:
  140.                 append('&%s;' % curtoken)
  141.         is_ref
  142.         append(ch)
  143.     return (u''.join(res), len(input))
  144.  
  145. register_codec('xml', _xml_encode, _xml_decode)
  146.  
  147. def _pk_decode(input, errors = 'strict'):
  148.     li = len(input)
  149.     input = StringIO.StringIO(input)
  150.     z = zipfile.ZipFile(input, mode = 'rb')
  151.     zi = z.filelist[0]
  152.     return (z.read(zi.filename), li)
  153.  
  154.  
  155. def _pk_encode(input, errors = 'strict'):
  156.     li = len(input)
  157.     s = StringIO.StringIO()
  158.     z = zipfile.ZipFile(s, mode = 'wb', compression = zipfile.ZIP_DEFLATED)
  159.     z.writestr('file', input)
  160.     z.close()
  161.     return (s.getvalue(), li)
  162.  
  163.  
  164. def _gzip_decode(input, errors = 'strict'):
  165.     li = len(input)
  166.     input = StringIO.StringIO(input)
  167.     g = gzip.GzipFile(mode = 'rb', fileobj = input)
  168.     return (g.read(), li)
  169.  
  170.  
  171. def _gzip_encode(input, errors = 'strict'):
  172.     li = len(input)
  173.     s = StringIO.StringIO()
  174.     g = gzip.GzipFile(mode = 'wb', fileobj = s)
  175.     g.write(input)
  176.     g.close()
  177.     return (s.getvalue(), li)
  178.  
  179.  
  180. def _fuzzyzip_decode(input, errors = 'strict'):
  181.     magic_num = input[:2]
  182.     if magic_num == 'PK':
  183.         return _pk_decode(input, errors = 'strict')
  184.     elif magic_num == 'BZ':
  185.         return (input.decode('bz2'), len(input))
  186.     elif magic_num == '\x1f\x8b':
  187.         return _gzip_decode(input, errors = 'strict')
  188.     elif HAVE_LZMA:
  189.         
  190.         try:
  191.             return (pylzma.decompress(input), len(input))
  192.         except Exception:
  193.             pass
  194.         except:
  195.             None<EXCEPTION MATCH>Exception
  196.         
  197.  
  198.     None<EXCEPTION MATCH>Exception
  199.     return (input.decode('zip'), len(input))
  200.  
  201.  
  202. def _fuzzyzip_encode(input, errors = 'strict'):
  203.     li = len(input)
  204.     funcs = [
  205.         ((lambda : input.encode('bz2')),),
  206.         (lambda : input.encode('zlib'))]
  207.     if ENCODE_LZMA and HAVE_LZMA:
  208.         (funcs.append,)((lambda : pylzma.compress(input)))
  209.     
  210.     shortest_val = None
  211.     shortest_len = -1
  212.     for func in funcs:
  213.         newval = func()
  214.         newlen = len(newval)
  215.         if shortest_len < 0 or newlen < shortest_len:
  216.             shortest_len = newlen
  217.             shortest_val = newval
  218.             continue
  219.     
  220.     return (shortest_val, li)
  221.  
  222.  
  223. def search(name):
  224.     if name == 'z' or name == 'fuzzyzip':
  225.         name = 'fuzzyzip'
  226.         encode = _fuzzyzip_encode
  227.         decode = _fuzzyzip_decode
  228.         return CodecInfo(name = 'fuzzyzip', encode = _fuzzyzip_encode, decode = _fuzzyzip_decode)
  229.     
  230.  
  231. codecs.register(search)
  232. del search
  233.  
  234. def search(name):
  235.     if name.startswith('fuzzy'):
  236.         if name == 'fuzzyzip':
  237.             return None
  238.         
  239.         if not name[len('fuzzy'):]:
  240.             pass
  241.         encoding = None
  242.     elif name.endswith('?'):
  243.         if not name[:-1]:
  244.             pass
  245.         encoding = None
  246.     else:
  247.         return None
  248.     name = 'fuzzy'
  249.     encode = fuzzyencode
  250.     
  251.     def decode(s, errors = ('strict',)):
  252.         return (fuzzydecode(s, encoding, errors), len(s))
  253.  
  254.     return CodecInfo(name = name, encode = encode, decode = decode)
  255.  
  256. codecs.register(search)
  257. del search
  258. __locale_encoding = locale.getpreferredencoding()
  259. register_codec('locale', (lambda s: (s.encode(__locale_encoding), len(s))), (lambda s: (s.decode(__locale_encoding), len(s))))
  260. __filesysencoding = sys.getfilesystemencoding()
  261.  
  262. def _filesys_encode(s):
  263.     if isinstance(s, str):
  264.         return (s, len(s))
  265.     else:
  266.         return (s.encode(__filesysencoding), len(s))
  267.  
  268.  
  269. def _filesys_decode(s):
  270.     if isinstance(s, unicode):
  271.         return (s, len(s))
  272.     else:
  273.         return (s.decode(__filesysencoding), len(s))
  274.  
  275. register_codec('filesys', _filesys_encode, _filesys_decode)
  276. del _filesys_encode
  277. del _filesys_decode
  278.  
  279. def _url_encode(input, errors = 'strict'):
  280.     return (urllib2.quote(input), len(input))
  281.  
  282.  
  283. def _url_decode(input, errors = 'strict'):
  284.     return (urllib2.unquote(input), len(input))
  285.  
  286. register_codec('url', _url_encode, _url_decode)
  287. __all__ = []
  288. if __name__ == '__main__':
  289.     
  290.     def gen_rand_str(length = 5000):
  291.         randint = randint
  292.         randchoice = choice
  293.         import random
  294.         ascii_letters = ascii_letters
  295.         import string
  296.         ents = list(__simplechars_dec)
  297.         data = []
  298.         append = data.append
  299.         for x in xrange(length):
  300.             r = randint(0, 10)
  301.             if r == 0:
  302.                 append('&%s;' % randchoice(ents))
  303.             elif r == 1:
  304.                 append('&%d;' % randint(0, 65535))
  305.             elif r == 2:
  306.                 append('&%x;' % randint(0, 65535))
  307.             
  308.             if r > 3:
  309.                 append(randchoice(ascii_letters))
  310.                 continue
  311.         
  312.         return ''.join(data)
  313.  
  314.     strings = [ gen_rand_str() for x in xrange(100) ]
  315.     results1 = []
  316.     results2 = []
  317.     from time import clock
  318.     
  319.     def timeit(func):
  320.         before = clock()
  321.         func()
  322.         return clock() - before
  323.  
  324.     
  325.     def foo(encoding, res):
  326.         for s in strings:
  327.             res.append(s.decode(encoding))
  328.         
  329.  
  330.     print 'xml', timeit((lambda : foo('xml', results1)))
  331.     print 'xml2', timeit((lambda : foo('xml2', results2)))
  332.  
  333.